package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import br.com.telescope.t2.feature.AbstractFeature;
import javax.script.ScriptEngine;
import br.com.telescope.t2.exception.UnexpectedException;
import br.com.telescope.t2.ServiceUrlManager;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.AccessDeniedException;
import br.com.telescope.t2.exception.UserNotLoggedException;
import br.com.telescope.util.ExceptionUtils;

/**
 * API de persistência de dados da entidade OPERACOES_SISTEMAS
 * @author Gerado pelo Telescope
 */
public class EntOperacoesSistemas extends Entity {
    
    public final static String ENTITY_NAME = "RTSYSINF.OPERACOES_SISTEMAS";
    public final static String TABLE_NAME = "OPERACOES_SISTEMAS";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntOperacoesSistemas() {
        super();
        initialize();
    }
    
    public EntOperacoesSistemas(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aInterfaceId = new DomId(this,"INTERFACE_ID", "Interface do sistema"); 
        oInterfaceId = new DomId();
        aOperacao = new DomUpper(this,"OPERACAO", "Operação"); 
        aOperacao.setRequired(true);
        aOperacao.setSize(300);
        oOperacao = new DomUpper();
        aTitulo = new DomText(this,"TITULO", "Título"); 
        aTitulo.setRequired(true);
        aTitulo.setSize(250);
        oTitulo = new DomText();
        aPoliticaAcesso = new DomOpcao(this,"POLITICA_ACESSO", "Política de acesso"); 
        aPoliticaAcesso.setSize(1);
        aPoliticaAcesso.clearOptions();
        aPoliticaAcesso.addOption("P", "Público");
        aPoliticaAcesso.addOption("R", "Restrito");
        aPoliticaAcesso.addOption("U", "Usuário");
        aPoliticaAcesso.setDefaultValue("R");
        oPoliticaAcesso = new DomOpcao();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição"); 
        oDescricao = new DomTextLong();
        aTipo = new DomOpcao(this,"TIPO", "Tipo"); 
        aTipo.setRequired(true);
        aTipo.setSize(1);
        aTipo.clearOptions();
        aTipo.addOption("I", "Implementação custom");
        aTipo.addOption("R", "Report");
        aTipo.addOption("S", "Service");
        aTipo.addOption("U", "User interface");
        aTipo.setDefaultValue("U");
        oTipo = new DomOpcao();
        aTipoImplementacaoId = new DomId(this,"TIPO_IMPLEMENTACAO_ID", "Tipo de implementação"); 
        oTipoImplementacaoId = new DomId();
        aImplementacao = new DomSourceCode(this,"IMPLEMENTACAO", "Implementação"); 
        oImplementacao = new DomSourceCode();
        aSituacao = new DomOpcao(this,"SITUACAO", "Situação"); 
        aSituacao.setRequired(true);
        aSituacao.setSize(1);
        aSituacao.clearOptions();
        aSituacao.addOption("A", "Ativo");
        aSituacao.addOption("I", "Inativo");
        aSituacao.setDefaultValue("A");
        oSituacao = new DomOpcao();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Interface do sistema
    private DomId aInterfaceId;
    private DomId oInterfaceId;
    
    // Operação
    private DomUpper aOperacao;
    private DomUpper oOperacao;
    
    // Título
    private DomText aTitulo;
    private DomText oTitulo;
    
    // Política de acesso
    private DomOpcao aPoliticaAcesso;
    private DomOpcao oPoliticaAcesso;
    
    // Descrição
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // Tipo
    private DomOpcao aTipo;
    private DomOpcao oTipo;
    
    // Tipo de implementação
    private DomId aTipoImplementacaoId;
    private DomId oTipoImplementacaoId;
    
    // Implementação
    private DomSourceCode aImplementacao;
    private DomSourceCode oImplementacao;
    
    // Situação
    private DomOpcao aSituacao;
    private DomOpcao oSituacao;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntOperacoesSistemas id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INTERFACE_ID">
    
    public EntOperacoesSistemas interfaceId(Long value) {
        setInterfaceId(value);
        return this;
    }
    
    public void setInterfaceId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyInterfaceId();
        } else {
            aInterfaceId.setValue(value.getValue());
            if (aInterfaceId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInterfaceId(String value) {
        if (value == null) {
            nullifyInterfaceId();
        } else {
            aInterfaceId.setValue(value);
            if (aInterfaceId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInterfaceId(Long value) {
        aInterfaceId.setValue(value);
        if (aInterfaceId.isModified()) {
            setModified(true);
        }
    }
    
    public void setInterfaceId(Object value) {
        aInterfaceId.setValue(value);
        if (aInterfaceId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyInterfaceId() {
        if (!aInterfaceId.isNull()) {
            aInterfaceId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getInterfaceId() {
        return aInterfaceId;
    }
    
    public DomId oldInterfaceId() {
        return oInterfaceId;
    }
    
    public Long valueOfInterfaceId() {
        return aInterfaceId.getValue();
    }
    
    public boolean isInterfaceIdModified() {
        return aInterfaceId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo OPERACAO">
    
    public EntOperacoesSistemas operacao(String value) {
        setOperacao(value);
        return this;
    }
    
    public void setOperacao(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyOperacao();
        } else {
            aOperacao.setValue(value.getValue());
            if (aOperacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperacao(String value) {
        if (value == null) {
            nullifyOperacao();
        } else {
            aOperacao.setValue(value);
            if (aOperacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOperacao(Object value) {
        aOperacao.setValue(value);
        if (aOperacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOperacao() {
        if (!aOperacao.isNull()) {
            aOperacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getOperacao() {
        return aOperacao;
    }
    
    public DomUpper oldOperacao() {
        return oOperacao;
    }
    
    public String valueOfOperacao() {
        return aOperacao.getValue();
    }
    
    public boolean isOperacaoModified() {
        return aOperacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TITULO">
    
    public EntOperacoesSistemas titulo(String value) {
        setTitulo(value);
        return this;
    }
    
    public void setTitulo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value.getValue());
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(String value) {
        if (value == null) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value);
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(Object value) {
        aTitulo.setValue(value);
        if (aTitulo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTitulo() {
        if (!aTitulo.isNull()) {
            aTitulo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getTitulo() {
        return aTitulo;
    }
    
    public DomText oldTitulo() {
        return oTitulo;
    }
    
    public String valueOfTitulo() {
        return aTitulo.getValue();
    }
    
    public boolean isTituloModified() {
        return aTitulo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo POLITICA_ACESSO">
    
    public EntOperacoesSistemas politicaAcesso(String value) {
        setPoliticaAcesso(value);
        return this;
    }
    
    public void setPoliticaAcesso(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyPoliticaAcesso();
        } else {
            aPoliticaAcesso.setValue(value.getValue());
            if (aPoliticaAcesso.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPoliticaAcesso(String value) {
        if (value == null) {
            nullifyPoliticaAcesso();
        } else {
            aPoliticaAcesso.setValue(value);
            if (aPoliticaAcesso.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPoliticaAcesso(Object value) {
        aPoliticaAcesso.setValue(value);
        if (aPoliticaAcesso.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPoliticaAcesso() {
        if (!aPoliticaAcesso.isNull()) {
            aPoliticaAcesso.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getPoliticaAcesso() {
        return aPoliticaAcesso;
    }
    
    public DomOpcao oldPoliticaAcesso() {
        return oPoliticaAcesso;
    }
    
    public String valueOfPoliticaAcesso() {
        return aPoliticaAcesso.getValue();
    }
    
    public boolean isPoliticaAcessoModified() {
        return aPoliticaAcesso.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntOperacoesSistemas descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO">
    
    public EntOperacoesSistemas tipo(String value) {
        setTipo(value);
        return this;
    }
    
    public void setTipo(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyTipo();
        } else {
            aTipo.setValue(value.getValue());
            if (aTipo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipo(String value) {
        if (value == null) {
            nullifyTipo();
        } else {
            aTipo.setValue(value);
            if (aTipo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipo(Object value) {
        aTipo.setValue(value);
        if (aTipo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipo() {
        if (!aTipo.isNull()) {
            aTipo.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getTipo() {
        return aTipo;
    }
    
    public DomOpcao oldTipo() {
        return oTipo;
    }
    
    public String valueOfTipo() {
        return aTipo.getValue();
    }
    
    public boolean isTipoModified() {
        return aTipo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_IMPLEMENTACAO_ID">
    
    public EntOperacoesSistemas tipoImplementacaoId(Long value) {
        setTipoImplementacaoId(value);
        return this;
    }
    
    public void setTipoImplementacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyTipoImplementacaoId();
        } else {
            aTipoImplementacaoId.setValue(value.getValue());
            if (aTipoImplementacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoImplementacaoId(String value) {
        if (value == null) {
            nullifyTipoImplementacaoId();
        } else {
            aTipoImplementacaoId.setValue(value);
            if (aTipoImplementacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoImplementacaoId(Long value) {
        aTipoImplementacaoId.setValue(value);
        if (aTipoImplementacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setTipoImplementacaoId(Object value) {
        aTipoImplementacaoId.setValue(value);
        if (aTipoImplementacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoImplementacaoId() {
        if (!aTipoImplementacaoId.isNull()) {
            aTipoImplementacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getTipoImplementacaoId() {
        return aTipoImplementacaoId;
    }
    
    public DomId oldTipoImplementacaoId() {
        return oTipoImplementacaoId;
    }
    
    public Long valueOfTipoImplementacaoId() {
        return aTipoImplementacaoId.getValue();
    }
    
    public boolean isTipoImplementacaoIdModified() {
        return aTipoImplementacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo IMPLEMENTACAO">
    
    public EntOperacoesSistemas implementacao(String value) {
        setImplementacao(value);
        return this;
    }
    
    public void setImplementacao(DomSourceCode value) {
        if (value == null || value.isNull()) {
            nullifyImplementacao();
        } else {
            aImplementacao.setValue(value.getValue());
            if (aImplementacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setImplementacao(String value) {
        if (value == null) {
            nullifyImplementacao();
        } else {
            aImplementacao.setValue(value);
            if (aImplementacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setImplementacao(Object value) {
        aImplementacao.setValue(value);
        if (aImplementacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyImplementacao() {
        if (!aImplementacao.isNull()) {
            aImplementacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomSourceCode getImplementacao() {
        return aImplementacao;
    }
    
    public DomSourceCode oldImplementacao() {
        return oImplementacao;
    }
    
    public String valueOfImplementacao() {
        return aImplementacao.getValue();
    }
    
    public boolean isImplementacaoModified() {
        return aImplementacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO">
    
    public EntOperacoesSistemas situacao(String value) {
        setSituacao(value);
        return this;
    }
    
    public void setSituacao(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value.getValue());
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(String value) {
        if (value == null) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value);
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(Object value) {
        aSituacao.setValue(value);
        if (aSituacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacao() {
        if (!aSituacao.isNull()) {
            aSituacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getSituacao() {
        return aSituacao;
    }
    
    public DomOpcao oldSituacao() {
        return oSituacao;
    }
    
    public String valueOfSituacao() {
        return aSituacao.getValue();
    }
    
    public boolean isSituacaoModified() {
        return aSituacao.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade RTSYSINF.PARAMETROS_OPERACOES.FK_PAROPR_OPERACAO
        {
            EntParametrosOperacoes parametrosOperacoes = new EntParametrosOperacoes(ctx);
            parametrosOperacoes.del("select id from PARAMETROS_OPERACOES where OPERACAO_ID = " + valueOfId());
        }
        // Delete cascade RTSYSINF.OPERACOES_FUNCOES.FK_OPERACAO
        {
            EntOperacoesFuncoes operacoesFuncoes = new EntOperacoesFuncoes(ctx);
            operacoesFuncoes.del("select id from OPERACOES_FUNCOES where OPERACAO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_RELEMIT_OPRSIS_RELATORIO") >= 0) {
                e = new AdsException("RELEMIT.RELATORIOS_EMITIDOS.FK_RELEMIT_OPRSIS_RELATORIO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Relatorios emitidos fazendo referencia para este registro! (FK_RELEMIT_OPRSIS_RELATORIO)");
                return e;
            } else if (msg.indexOf("FK_JOBS_OPERACAO") >= 0) {
                e = new AdsException("SCHEDU.JOBS.FK_JOBS_OPERACAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Agenda de tarefas fazendo referencia para este registro! (FK_JOBS_OPERACAO)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PK_OPRSIS") >= 0) {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.PK_OPRSIS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_OPRSIS)");
                return e;
            } else if (msg.indexOf("UK_OPRSIS_OPERACAO") >= 0) {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.UK_OPRSIS_OPERACAO", 
                        Severity.ERROR,
                        "Registro duplicado! Não pode ter duas operações com o mesmo código Operação ${OPERACAO} (UK_OPRSIS_OPERACAO)");
                return e;
            } else if (msg.indexOf("FK_OPRSIS_INTERFACE") >= 0) {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_INTERFACE", 
                        Severity.ERROR,
                        "Registro não cadastrado para INTERFACE! (FK_OPRSIS_INTERFACE)");
                return e;
            } else if (msg.indexOf("FK_OPRSIS_TIPO_IMPLEMENTACAO") >= 0) {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_TIPO_IMPLEMENTACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para TIPO_IMPLEMENTACAO! (FK_OPRSIS_TIPO_IMPLEMENTACAO)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.OPERACOES_SISTEMAS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aInterfaceId);
            allAttributes.add(aOperacao);
            allAttributes.add(aTitulo);
            allAttributes.add(aPoliticaAcesso);
            allAttributes.add(aDescricao);
            allAttributes.add(aTipo);
            allAttributes.add(aTipoImplementacaoId);
            allAttributes.add(aImplementacao);
            allAttributes.add(aSituacao);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getOperacao().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByOperacao(String operacao) throws AdsException {
        findBy(new String[] {"OPERACAO"},
                new Object[] {operacao});
    }
    
    private EntInterfacesSistemas eInterface;
    
    public EntInterfacesSistemas findInterface() throws AdsException {
        if (getInterfaceId().isNull()) {
            return null;
        }
        if (eInterface == null || !valueOfInterfaceId().equals(eInterface.valueOfId())) {
            eInterface = new EntInterfacesSistemas(ctx);
            eInterface.find(valueOfInterfaceId());
        }
        return eInterface;
    }
    
    /**
     * Ativa o join desta entidade com INTERFACES_SISTEMAS
     * através do atributo INTERFACE_ID
     */
    public EntInterfacesSistemas joinInterface() {
        return joinInterface(null);
    }
    public EntInterfacesSistemas joinInterface(String alias) {
        EntInterfacesSistemas entity = new EntInterfacesSistemas(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getInterfaceId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByInterface(long id, String sqlAppend) throws AdsException {
        find("select ID from OPERACOES_SISTEMAS where INTERFACE_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByInterface(long id) throws AdsException {
        findByInterface(id,"");
    }
    
    public void findByInterface(Entity entidade) throws AdsException {
        findByInterface(entidade.valueOfId(),"");
    }
    
    public void findByInterface(Entity entidade, String sqlAppend) throws AdsException {
        findByInterface(entidade.valueOfId(),sqlAppend);
    }
    
    private EntTiposImplementacoes eTipoImplementacao;
    
    public EntTiposImplementacoes findTipoImplementacao() throws AdsException {
        if (getTipoImplementacaoId().isNull()) {
            return null;
        }
        if (eTipoImplementacao == null || !valueOfTipoImplementacaoId().equals(eTipoImplementacao.valueOfId())) {
            eTipoImplementacao = new EntTiposImplementacoes(ctx);
            eTipoImplementacao.find(valueOfTipoImplementacaoId());
        }
        return eTipoImplementacao;
    }
    
    /**
     * Ativa o join desta entidade com TIPOS_IMPLEMENTACOES
     * através do atributo TIPO_IMPLEMENTACAO_ID
     */
    public EntTiposImplementacoes joinTipoImplementacao() {
        return joinTipoImplementacao(null);
    }
    public EntTiposImplementacoes joinTipoImplementacao(String alias) {
        EntTiposImplementacoes entity = new EntTiposImplementacoes(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getTipoImplementacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByTipoImplementacao(long id, String sqlAppend) throws AdsException {
        find("select ID from OPERACOES_SISTEMAS where TIPO_IMPLEMENTACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByTipoImplementacao(long id) throws AdsException {
        findByTipoImplementacao(id,"");
    }
    
    public void findByTipoImplementacao(Entity entidade) throws AdsException {
        findByTipoImplementacao(entidade.valueOfId(),"");
    }
    
    public void findByTipoImplementacao(Entity entidade, String sqlAppend) throws AdsException {
        findByTipoImplementacao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eInterface = null;
        eTipoImplementacao = null;
    }
    /**
     * Retorna os registros de OPERACOES_FUNCOES que referenciam este registro através do atributo OPERACAO_ID
     */
    public EntOperacoesFuncoes findAllOperacoesFuncoesOperacao() throws AdsException {
        return findAllOperacoesFuncoesOperacao("order by ID");
    }
    
    /**
     * Retorna os registros de OPERACOES_FUNCOES que referenciam este registro através do atributo OPERACAO_ID
     */
    public EntOperacoesFuncoes findAllOperacoesFuncoesOperacao(String sqlAppend) throws AdsException {
        EntOperacoesFuncoes out = new EntOperacoesFuncoes(ctx);
        out.find("select ID from OPERACOES_FUNCOES where OPERACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PARAMETROS_OPERACOES que referenciam este registro através do atributo OPERACAO_ID
     */
    public EntParametrosOperacoes findAllParametrosOperacoesOperacao() throws AdsException {
        return findAllParametrosOperacoesOperacao("order by ID");
    }
    
    /**
     * Retorna os registros de PARAMETROS_OPERACOES que referenciam este registro através do atributo OPERACAO_ID
     */
    public EntParametrosOperacoes findAllParametrosOperacoesOperacao(String sqlAppend) throws AdsException {
        EntParametrosOperacoes out = new EntParametrosOperacoes(ctx);
        out.find("select ID from PARAMETROS_OPERACOES where OPERACAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oSituacao.setValue(aSituacao);
        oId.setValue(aId);
        oDescricao.setValue(aDescricao);
        oInterfaceId.setValue(aInterfaceId);
        oTitulo.setValue(aTitulo);
        oOperacao.setValue(aOperacao);
        oTipoImplementacaoId.setValue(aTipoImplementacaoId);
        oTipo.setValue(aTipo);
        oPoliticaAcesso.setValue(aPoliticaAcesso);
        oImplementacao.setValue(aImplementacao);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setAssociatedEntity(EntTiposImplementacoes.class);
            rule.setName("FK_OPRSIS_TIPO_IMPLEMENTACAO");
            rule.addAttribute(new DomId("TIPO_IMPLEMENTACAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setName("UK_OPRSIS_OPERACAO");
            rule.addAttribute(new DomUpper("OPERACAO",""));
            out.add(rule);
        }
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setName("PK_OPRSIS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setAssociatedEntity(EntInterfacesSistemas.class);
            rule.setName("FK_OPRSIS_INTERFACE");
            rule.addAttribute(new DomId("INTERFACE_ID",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setCheckAttribute(new DomOpcao("POLITICA_ACESSO",""));
            rule.setName("CKAV_243003");
            rule.addAllowableValues(new String[] {"P", "R", "U"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setCheckAttribute(new DomOpcao("TIPO",""));
            rule.setName("CKAV_263527");
            rule.addAllowableValues(new String[] {"I", "R", "S", "U"});
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntOperacoesSistemas.class);
            rule.setCheckAttribute(new DomOpcao("SITUACAO",""));
            rule.setName("CKAV_20738092");
            rule.addAllowableValues(new String[] {"A", "I"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        criarInterface(); //Criar interface
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        criarInterface(); //Criar interface
    }
    
    @Override
    protected void posDelete() throws AdsException {
        excluirInterface(); //Excluir interface
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getSituacao().isNull()) {
            setSituacao(getSituacao().getDefaultValue());
        }
        if (getTipo().isNull()) {
            setTipo(getTipo().getDefaultValue());
        }
        if (getPoliticaAcesso().isNull()) {
            setPoliticaAcesso(getPoliticaAcesso().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Atualizar.
     * <p>
     * Atualiza a base de dados com todas as operações disponíveis do 
     * sistema. Retorna um texto contendo as atualizações realizadas, 
     * relatando as operações inseridas, alteradas e/ou excluídas.
     */
    public String atualizar() throws AdsException {
        // <user-code id="16024812" parentId="16024811" hashcode="-4368ef84" length="6395">
        // import javax.xml.parsers.DocumentBuilder;
        // import javax.xml.parsers.DocumentBuilderFactory;
        // import org.w3c.dom.Document;
        // import org.w3c.dom.Element;
        // import org.w3c.dom.Node;
        // import org.w3c.dom.NodeList;
        StringBuilder out = new StringBuilder(200);
        EntInterfacesSistemas interfaceSistema = new EntInterfacesSistemas(ctx);
        EntOperacoesSistemas operacao = new EntOperacoesSistemas(ctx);
        
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder loader = factory.newDocumentBuilder();
        
            Document document = loader.parse(getClass().getResourceAsStream("/../app-info.xml"));
            Element tree = document.getDocumentElement();
        
            NodeList list = tree.getChildNodes();
        
            for (int i = 0; i < list.getLength(); i++) {
                Node node = list.item(i);
                if (node.getNodeName().equals("interface")) {
                    NodeList childnodes = node.getChildNodes();
                    String name = null;
                    String title = null;
                    ArrayList nodes = new ArrayList();
        
                    for (int j = 0; j < childnodes.getLength(); j++) {
                        Node nodeitem = childnodes.item(j);
                        if (nodeitem.getNodeName().equals("name")) {
                            name = nodeitem.getTextContent();
                        }
                        if (nodeitem.getNodeName().equals("title")) {
                            title = nodeitem.getTextContent();
                        }
                        if (nodeitem.getNodeName().equals("operation")) {
                            nodes.add(nodeitem.getChildNodes());
                        }
                    }
                    
                    interfaceSistema.nullify();
                    try {
                        interfaceSistema.findByNome(name);
                        interfaceSistema.setTitulo(title);
                        if (interfaceSistema.isModified()) {
                            out.append("\nInterface ").append(name).append(" atualizada - ").append(title);
                            interfaceSistema.upd();
                        }
                    } catch (RecordNotFoundException ex) {
                        interfaceSistema.setNome(name);
                        interfaceSistema.setTitulo(title);
                        interfaceSistema.ins();
                        out.append("\nInterface ").append(name).append(" inserida - ").append(title);
                    }
        
                    for (Object oNode : nodes) {
                        NodeList nodelist = (NodeList) oNode;
                        String oName = null;
                        String oTitle = null;
                        String oAccess = null;
                        for (int k = 0; k < nodelist.getLength(); k++) {
                            Node item = nodelist.item(k);
                            if (item.getNodeName().equals("name")) {
                                oName = item.getTextContent();
                            }
                            if (item.getNodeName().equals("title")) {
                                oTitle = item.getTextContent();
                            }
                            if (item.getNodeName().equals("access-policy")) {
                                oAccess = item.getTextContent();
                            }
                        }
                        String oGlobal = name + "." + oName;
                        try {
                            operacao.findByOperacao(oGlobal);
                            operacao.setPoliticaAcesso(oAccess);
                            if (oTitle == null || oTitle.length() == 0) {
                                oTitle = oName;
                            }
                            operacao.setTitulo(oTitle);
                            if (operacao.isModified()) {
                                out.append("\nOperação ").append(oGlobal).append(" atualizada");
                                operacao.upd();
                            }
                        } catch (RecordNotFoundException ex) {
                            operacao.nullify();
                            operacao.setOperacao(oGlobal);
                            operacao.setInterfaceId(interfaceSistema.valueOfId());
                            operacao.setPoliticaAcesso(oAccess);
                            if (oTitle == null || oTitle.length() == 0) {
                                oTitle = oName;
                            }
                            operacao.setTitulo(oTitle);
                            operacao.ins();
                            out.append("\nnOperação ").append(oGlobal).append(" inserida");
                        }
                    }
                } else if (node.getNodeName().equals("preference")) {
                    NodeList nodelist = node.getChildNodes();
                    String name = null;
                    String description = "?";
                    String value = null;
                    String perUser = "N";
        
                    for (int j = 0; j < nodelist.getLength(); j++) {
                        Node item = nodelist.item(j);
                        if (item.getNodeName().equals("name")) {
                            name = item.getTextContent();
                        }
                        if (item.getNodeName().equals("description")) {
                            description = item.getTextContent();
                        }
                        if (item.getNodeName().equals("value")) {
                            value = item.getTextContent();
                        }
                        if (item.getNodeName().equals("peruser")) {
                            perUser = item.getTextContent();
                        }
                    }
        
                    if (name != null) {
                        EntPreferencias pref = new EntPreferencias(ctx);
                        try {
                            pref.findByPreferencia(name);
                            if (!pref.valueOfDescricao().equals(description)) {
                                pref.setDescricao(description);
                            }
                            if (!pref.valueOfPorUsuario().equals(perUser)) {
                                pref.setPorUsuario(perUser);
                            }
                            if (pref.isModified()) {
                                out.append("\nPreferencia ").append(name).append(" atualizada!");
                                pref.upd();
                            }
                        } catch (RecordNotFoundException ex) {
                            pref.setPreferencia(name);
                            pref.setDescricao(description);
                            pref.setValor(value);
                            pref.setPorUsuario(perUser);
                            pref.ins();
                            out.append("\nPreferencia ").append(name).append(" inserida!");
                        }
                    }
                }
            }
        
        } catch (Exception ex) {
            throw new UnexpectedException(ex);
        }
        return out.toString();
        // </user-code>
    }
    
    /**
     * Notify.
     * <p>
     * Recebe eventos de upgrade.
     * <P>
     */
    public void notify(String evento, Object feature) throws AdsException {
        // <user-code id="20740756" parentId="20740746" hashcode="19dab9b1" length="545">
        // import br.com.telescope.t2.feature.AbstractFeature;
        if ("RT.POS_UPGRADE".equals(evento)) {
            //ProAtualizacoes at = new ProAtualizacoes(); importando classe do eligo....
            AbstractFeature instance = (AbstractFeature) feature;
            String operacao = instance.globalName();
            EntOperacoesSistemas oper = new EntOperacoesSistemas(ctx);
            oper.findByOperacao(operacao);
            oper.setSituacao("I");
            oper.upd();
            if (instance.getForm().size() > 0) {
                instance.getServiceModel().redirectTo("ProAtualizacoes");
            }
        }
        // </user-code>
    }
    
    /**
     * Run.
     * <p>
     * Executa o procedimento.
     * <P>
     */
    public void run() throws AdsException {
        // <user-code id="2282407" parentId="2282406" hashcode="-27839b57" length="2529">
        // import javax.script.ScriptEngine;
        // import br.com.telescope.t2.exception.UnexpectedException;
        // import br.com.telescope.t2.ServiceUrlManager;
        // import br.com.telescope.t2.ServiceModel;
        // import br.com.telescope.t2.feature.AbstractFeature;
        // import br.com.telescope.t2.exception.AccessDeniedException;
        // import br.com.telescope.t2.exception.UserNotLoggedException;
        // import br.com.telescope.util.ExceptionUtils;
        try {
            if (getTipoImplementacaoId().isNull()) {
                ServletRuntime ct2;
                if (ctx instanceof ServletRuntime) {
                    ct2 = (ServletRuntime) ctx;
                } else {
                    ct2 = new ServletRuntime(ctx);
                }
                ServiceModel service;
                AbstractFeature feature;
                if ("R".equals(valueOfTipo())) {
                    service = ServiceUrlManager.newService("REPORTS.PRO_REPORT2");
                    feature = service.getFeature("EXEC").action("SUBMIT");
                    feature.setContext(ct2);
                    ct2.setParameter("A_ID", getId());
                } else {
                    EntInterfacesSistemas intf = findInterface();
                    ServiceUrlManager manager = ServiceUrlManager.getInstance();
                    Class<ServiceModel> sclass = manager.getClassForService(intf.valueOfNome());
                    service = sclass.newInstance();
                    String fname = valueOfOperacao().substring(valueOfOperacao().lastIndexOf(".") + 1);
                    feature = service.getFeature(fname);
                    feature.setContext(ct2);
                }
                String zAction = ctx.getParameter("Z_ACTION");
                int p = zAction.indexOf(":");
                if (p >= 0) {
                    feature.setAction(zAction.substring(p + 1));
                }
        
                service.setRuntime(ct2);
                service.init();
                feature.checkUserAccess();
                feature.run();
            } else {
                EntTiposImplementacoes tipo = findTipoImplementacao();
                String classname = tipo.valueOfMecanismoExecucao();
                Class<ScriptEngine> clazz = (Class<ScriptEngine>) Class.forName(classname);
                ScriptEngine engine = clazz.newInstance();
                engine.put("ctx", ctx);
                engine.eval(valueOfImplementacao());
            }
        } catch (UserNotLoggedException ex) {
            throw new UnexpectedException("Esta operação exige que um usuário seja informado!");
        } catch (AccessDeniedException ex) {
            throw new UnexpectedException("Usuário informado no job não tem acesso à esta operação!");
        } catch (Exception ex) {
            throw new UnexpectedException(ExceptionUtils.getDetailedMessage(ex), ex);
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Excluir interface
     * 
     * Ao excluir um tipo custom, deve excluir a interface.
     */
    private void excluirInterface() throws AdsException {
        // <user-code id="2021391" parentId="2021276" hashcode="3e1c814c" length="84">
        if (aTipo.in("I", "R") && aInterfaceId.isNotNull()) {
            findInterface().del();
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Criar interface
     * 
     * Quando a operação puder ser considerada como uma interface, criar uma 
     * interface automaticamente.
     */
    private void criarInterface() throws AdsException {
        // <user-code id="2021390" parentId="2021259" hashcode="55a27e25" length="528">
        //if ("I".equals(aTipo.getValue())) {
        if (aTipo.getValue() != null && aTipo.in("I", "R")) {
            if (aInterfaceId.isNull()) {
                EntInterfacesSistemas intf = new EntInterfacesSistemas(ctx);
                intf.setTitulo(aTitulo);
                intf.setNome(aOperacao);
        		intf.setTipoRegistro(aTipo);
                intf.ins();
                setInterfaceId(intf.valueOfId());
            } else {
                EntInterfacesSistemas intf = findInterface();
                intf.setTitulo(aTitulo);
                intf.setNome(aOperacao);
                intf.upd();
            }
        }
        // </user-code>
    }
}
